﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using System.Web;
using RechercheEmplois.Models;

namespace RechercheEmplois.DAL
{

    public class UnitOfWork : IDisposable
    {
        private ApplicationDbContext context = new ApplicationDbContext();
        private GenericRepository<Domaine> domaineRepository;
        private GenericRepository<MotCle> motCleRepository;
        private GenericRepository<Offre> offreRepository;
        private GenericRepository<Postule> postuleRepository;
        private GenericRepository<Provine> provineRepository;
        private GenericRepository<Ville> villeRepository;
        private GenericRepository<Sauvegarde> sauvegardeCleRepository;
        private GenericRepository<Utilisateur> utilisateurRepository;
        private GenericRepository<GroupUtilisateur> groupRepository;
 
        public GenericRepository<Domaine> DomaineRepository
        {
            get
            {

                if (this.domaineRepository == null)
                {
                    this.domaineRepository = new GenericRepository<Domaine>(context);
                }
                return domaineRepository;
            }
        }

        public GenericRepository<MotCle> MotCleRepository
        {
            get
            {

                if (this.motCleRepository == null)
                {
                    this.motCleRepository = new GenericRepository<MotCle>(context);
                }
                return motCleRepository;
            }
        }

        public GenericRepository<Offre> OffreRepository
        {
            get
            {

                if (this.offreRepository == null)
                {
                    this.offreRepository = new GenericRepository<Offre>(context);
                }
                return offreRepository;
            }
        }

        public GenericRepository<Postule> PostuleRepository
        {
            get
            {

                if (this.postuleRepository == null)
                {
                    this.postuleRepository = new GenericRepository<Postule>(context);
                }
                return postuleRepository;
            }
        }


        public GenericRepository<Provine> ProvineRepository
        {
            get
            {

                if (this.provineRepository == null)
                {
                    this.provineRepository = new GenericRepository<Provine>(context);
                }
                return provineRepository;
            }
        }


        public GenericRepository<Ville> VilleRepository
        {
            get
            {

                if (this.villeRepository == null)
                {
                    this.villeRepository = new GenericRepository<Ville>(context);
                }
                return villeRepository;
            }
        }

        public GenericRepository<Sauvegarde> SauvegardeRepository
        {
            get
            {

                if (this.sauvegardeCleRepository == null)
                {
                    this.sauvegardeCleRepository = new GenericRepository<Sauvegarde>(context);
                }
                return sauvegardeCleRepository;
            }
        }

        public GenericRepository<Utilisateur> UtilisateurRepository
        {
            get
            {

                if (this.utilisateurRepository == null)
                {
                    this.utilisateurRepository = new GenericRepository<Utilisateur>(context);
                }
                return utilisateurRepository;
            }
        }

        public GenericRepository<GroupUtilisateur> GroupRepository
        {
            get
            {

                if (this.groupRepository == null)
                {
                    this.groupRepository = new GenericRepository<GroupUtilisateur>(context);
                }
                return groupRepository;
            }
        }

        public void Save()
        {
            context.SaveChanges();
        }

        private bool disposed = false;

        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                if (disposing)
                {
                    context.Dispose();
                }
            }
            this.disposed = true;
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
    }
}